﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using SIIV.Data;

namespace SIIV.View.Desktop
{
    public partial class frmProtocolos : frmBase
    {
        int idMuestraSeleccionada;
        int idAnalisisSeleccionado;
        string contraseña;
        TabPage tabAnalisis, tabResultados;
        int idProtocolo;
        Dictionary<string, int> veterinarios;
        private int tipoDeMuestraAnterior = -1;
        private bool validarCambioDeMuestra = false;


        public frmProtocolos()
        {
            InitializeComponent();
        }

        private void frmProtocolos_Load(object sender, EventArgs e)
        {
            tabAnalisis = tabControl1.TabPages[1];
            tabResultados = tabControl1.TabPages[2];
            tabControl1.TabPages.RemoveAt(1);
            tabControl1.TabPages.RemoveAt(1);

            cargarComboPosNeg();
            cargarUnidades();
            cargarEstadosDeAnalisis();

            cargarTiposDeMuestras(); 
            cargarVeterinarios();     

            datosMuestra.Text = "Datos Muestra";
            btnCancelarMuestra.Visible = false;
            btnCancelarAnalisis.Visible = false;
            
            tabControl1.Enabled = false;
                 
            linkAdministrarAnalisis.Visible = false;
            lblProtocolo.Visible = comboProtocolos.Visible = false;
            comboUnidades.Enabled = false;
            if (comboUnidades.Text == "Positivo o Negativo")
            {
                txtValor.Enabled = false;
                txtValor.Visible = false;
                comboUnidades.Visible = false;
                label4.Visible = false;
                comboPosNeg.Enabled = true;
                comboPosNeg.Visible = true;
            }
            else
            {
                txtValor.Enabled = true;
                txtValor.Visible = true;
                comboUnidades.Visible = true;
                label4.Visible = true;
                comboPosNeg.Enabled = false;
                comboPosNeg.Visible = false;
            }
        }

        private void cargarEstadosDeAnalisis()
        {
            comboEstadoDeAnalisis.DataSource = Enum.GetValues(typeof(SIIV.Business.AnalisisBusiness.EstadosDeAnalisis));
        }

        private void cargarTiposDeAnalisis()
        {
            comboTipoDeAnalisis.DataSource = Muestras.ObtenerTiposDeAnalisis(Convert.ToInt16(comboTiposDeMuestras.SelectedValue));
        }

        private void cargarVeterinarios()
        {
            veterinarios = new Dictionary<string, int>();
            foreach (Usuario u in Animales.ObtenerVeterinarios()) 
            {
                veterinarios.Add(u.Username, u.IdUsuario);
                comboVeterinarios.Items.Add(u);
            }
            comboVeterinarios.Items.Insert(0, "[SELECCIONE VETERINARIO]");
            comboVeterinarios.SelectedIndex = 0;
        }

        private void cargarTiposDeMuestras()
        {
            comboTiposDeMuestras.DataSource = Muestras.ObtenerTiposDeMuestras();
        }

        private void dgvMuestras_RowHeaderMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            if (!e.RowIndex.Equals(-1))
            {
                datosMuestra.Text = "Editar Muestra";
                btnCancelarMuestra.Visible = true;
                linkAdministrarAnalisis.Visible = true;
                cargarDatosMuestra(dgvMuestras.Rows[e.RowIndex]);
            }
        }

        private void dgvMuestras_MouseDown(object sender, MouseEventArgs e)
        {
            if (!dgvMuestras.HitTest(e.X, e.Y).RowIndex.Equals(-1))
            {
                dgvMuestras.ClearSelection();
                dgvMuestras.Rows[dgvMuestras.HitTest(e.X, e.Y).RowIndex].Selected = true;
            }
        }

        private void dgvIndicadores_MouseDown(object sender, MouseEventArgs e)
        {
            try
            {
                if (!dgvMuestras.HitTest(e.X, e.Y).RowIndex.Equals(-1))
                {
                    dgvIndicadores.ClearSelection();
                    dgvIndicadores.Rows[dgvIndicadores.HitTest(e.X, e.Y).RowIndex].Selected = true;
                }
            }
            catch
            { 
            }
        }

        private void modificarMuestraToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Int32 fila = dgvMuestras.Rows.GetFirstRow(DataGridViewElementStates.Selected);
            cargarDatosMuestra(dgvMuestras.Rows[fila]);
            linkAdministrarAnalisis.Visible = true;
            datosMuestra.Text = "Editar Muestra";
            btnCancelarMuestra.Visible = true;
        }

        private void cargarDatosMuestra(DataGridViewRow fila)
        {
            idMuestraSeleccionada = Convert.ToInt32(fila.Cells[5].Value);
            comboAnimales.SelectedIndex = comboAnimales.FindString(fila.Cells[0].Value.ToString());
            validarCambioDeMuestra = false;
            tipoDeMuestraAnterior = comboTiposDeMuestras.SelectedIndex = comboTiposDeMuestras.FindString(fila.Cells[1].Value.ToString());
            if (Convert.ToInt32(fila.Cells[3].Value) >= 1 || Convert.ToInt32(fila.Cells[4].Value) >= 1)
            {
                comboTiposDeMuestras.Enabled = false;
                comboAnimales.Enabled = false;
            }
            else
            {
                comboTiposDeMuestras.Enabled = true;
                comboAnimales.Enabled = true;
            }

            if (RolUsuarioLogueado == Business.Roles.Laboratorio)
            {
                foreach (Control c in datosMuestra.Controls)
                {
                    c.Enabled = c.Name == "linkAdministrarAnalisis";
                }
            }
        }

        private void eliminarMuestraToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Int32 fila = dgvMuestras.Rows.GetFirstRow(DataGridViewElementStates.Selected);
            try
            {
                Muestras.EliminarMuestra(Convert.ToInt32(dgvMuestras.Rows[fila].Cells[5].Value));
                dgvMuestras.Rows.Clear();
                dgvMuestras.ClearSelection();
                cargarMuestras();                
            }
            catch (Exception ex)
            {
                MostrarError(ex.Message);
            }
        }

        private void cargarAnimales()
        {
            comboAnimales.DisplayMember = "Nombre";
            comboAnimales.ValueMember = "IdAnimal";
            comboAnimales.DataSource = Animales.ObtenerAnimales(veterinarios[comboVeterinarios.Text], string.Empty, new Nullable<decimal>(), new Nullable<decimal>(), new Nullable<char>(), new Nullable<short>());
        }

        private void cargarDatosMuestra(DataGridViewCellMouseEventArgs e)
        {
            DataGridViewRow fila = dgvMuestras.Rows[e.RowIndex];
            datosMuestra.Text = "Editar Muestra: " + fila.Cells[3].Value.ToString() + ", " + fila.Cells[2].Value.ToString();
            idMuestraSeleccionada = Convert.ToInt32(fila.Cells[6].Value);
            contraseña = fila.Cells[7].Value.ToString();
        }

        private void reiniciarFormularioMuestra()
        {
            if (comboAnimales.Items.Count > 0)
            {
                comboAnimales.SelectedIndex = 0;
            }
            datosMuestra.Text = "Nueva Muestra";
            btnCancelarMuestra.Visible = false;
            idMuestraSeleccionada = 0;
            dgvMuestras.ClearSelection();
            linkAdministrarAnalisis.Visible = false;
            comboTiposDeMuestras.SelectedIndex = 0;
            comboTiposDeMuestras.Enabled = true;
            
        }

        private void reiniciarFormularioAnalisis()
        {
            datosAnalisis.Enabled = (RolUsuarioLogueado == Business.Roles.Administrativo);
            datosAnalisis.Text = "Nuevo Análisis";
            dgvAnalisis.ClearSelection();
            if (comboTipoDeAnalisis.Items.Count > 0) comboTipoDeAnalisis.SelectedIndex = 0;
            txtObservaciones.Text = string.Empty;
            idAnalisisSeleccionado = 0;
            if (comboEstadoDeAnalisis.Items.Count > 0) comboEstadoDeAnalisis.SelectedIndex = 0;
            comboEstadoDeAnalisis.Enabled = false;
            richHistorial.Text = string.Empty;
            if (tabControl1.TabPages.Count.Equals(3))
            {
                reiniciarFormularioResultadosDeAnalisis();
            }
            btnResultados.Visible = false;
            comboTipoDeAnalisis.Enabled = true;
       }

        private void reiniciarFormularioResultadosDeAnalisis()
        {
            comboUnidades.SelectedIndex = 0;
            comboIndicadores.SelectedIndex = 0;
            comboPosNeg.SelectedIndex = 0;
            txtValor.Text = string.Empty;
            tabControl1.TabPages.RemoveAt(2);   
        }

        private void linkAdministrarAnalisis_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            if (tabControl1.TabPages.Count.Equals(1))
            {
                tabControl1.TabPages.Add(tabAnalisis);                
            }
            tabControl1.TabPages[1].Text = string.Format("Análisis del animal {0}. Muestra: {1}", comboAnimales.Text, comboTiposDeMuestras.Text);
            tabControl1.SelectedTab = tabControl1.TabPages[1];
            cargarAnalisis();
            reiniciarFormularioAnalisis();
        }

        private void cargarAnalisis()
        {
            dgvAnalisis.Rows.Clear();
            foreach (Analisis a in Muestras.ObtenerAnalisis(idMuestraSeleccionada))
            {
                string historia = string.Empty;
                foreach (HistoriaDeAnalisis h in a.HistoriasDeAnalisis)
                {
                    historia += string.Format("{0} - {1}.", h.Fecha.ToString("dd/MM/yyyy"), h.Descripcion);
                }
                dgvAnalisis.Rows.Add(a.TipoDeAnalisis.Nombre, a.EstadoDeAnalisis.Nombre, historia, a.IdAnalisis, a.IdTipoDeAnalisis, a.IdEstadoDeAnalisis);
            }
            dgvAnalisis.ClearSelection();
            if (RolUsuarioLogueado == Business.Roles.Administrativo)
            {
                comboTipoDeAnalisis.Enabled = true;
                comboEstadoDeAnalisis.Enabled = true;
                txtObservaciones.Enabled = true;
                richHistorial.Enabled = true;
                btnGuardarAnalisis.Visible = true;
                btnGuardarAnalisis.Enabled = true;
            }
            else
            {
                comboTipoDeAnalisis.Enabled = false;
                comboEstadoDeAnalisis.Enabled = false;
                txtObservaciones.Enabled = false;
                richHistorial.Enabled = false;
            }
            btnCancelarAnalisis.Visible = true;
            btnCancelarAnalisis.Enabled = true;
            linkLabel1.Visible = false;
        }

        private void btnGuardarAnalisis_Click(object sender, EventArgs e)
        {
            try
            {
                if (MessageBox.Show("¿Desea guardar los datos del analisis " + "?", "Confirmación Datos", MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
                {
                    if (idAnalisisSeleccionado.Equals(0))
                    {
                        Muestras.AgregarAnalisis(idMuestraSeleccionada, Convert.ToInt16(comboTipoDeAnalisis.SelectedValue), txtObservaciones.Text, IdUsuarioLogueado);
                    }
                    else
                    {
                        Muestras.ActualizarAnalisis(idAnalisisSeleccionado, Convert.ToInt16(comboTipoDeAnalisis.SelectedValue), (short)(comboEstadoDeAnalisis.SelectedIndex + 1), txtObservaciones.Text, IdUsuarioLogueado);
                    }
                    cargarAnalisis();
                    reiniciarFormularioAnalisis();
                }
            }
            catch (Exception ex)
            {
                MostrarError(ex.Message);
            }
        }

        private void btnCancelarAnalisis_Click(object sender, EventArgs e)
        {
            reiniciarFormularioAnalisis();
            linkLabel1.Visible = false;
        }

        private void btnGuardarMuestra_Click(object sender, EventArgs e)
        {
             try
            {
                if (MessageBox.Show("¿Desea guardar los datos" + "?", "Confirmación Datos", MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
                {
                    if (idMuestraSeleccionada.Equals(0))
                    {
                        Muestras.GuardarMuestra(idProtocolo, Convert.ToInt32(comboAnimales.SelectedValue), Convert.ToInt16(comboTiposDeMuestras.SelectedValue), IdUsuarioLogueado);
                    }
                    else
                    {
                        Muestras.ActualizarMuestra(idProtocolo,idMuestraSeleccionada, Convert.ToInt32(comboAnimales.SelectedValue), Convert.ToInt16(comboTiposDeMuestras.SelectedValue));
                    }
                    cargarMuestras();
                    reiniciarFormularioMuestra();
                }
             }
              catch (Exception ex)
                {
                    MostrarError(ex.Message);
                }
        }

        private void cargarMuestras()
        {
            dgvMuestras.Rows.Clear();
            List<Muestra> muestras = Muestras.ObtenerMuestras(idProtocolo);
            bool sePuedeEliminar = true;
            foreach (Muestra m in muestras)
            {
                int cantidadAnalisisEnProceso = m.Analisis.Count(a => a.IdEstadoDeAnalisis.Equals(2) || a.IdEstadoDeAnalisis.Equals(3));
                dgvMuestras.Rows.Add(m.Animal.Nombre, m.TiposDeMuestra.Nombre, m.Analisis.Count(), m.Analisis.Count(a => a.IdEstadoDeAnalisis.Equals(2)), m.Analisis.Count(a => a.IdEstadoDeAnalisis.Equals(3)), m.IdMuestra);

                if (RolUsuarioLogueado == Business.Roles.Administrativo)
                {
                    sePuedeEliminar = cantidadAnalisisEnProceso.Equals(0) && sePuedeEliminar;
                    contextMenuStripMuestras.Items[1].Enabled = sePuedeEliminar;
                    dgvMuestras.Rows[dgvMuestras.Rows.Count - 1].ContextMenuStrip = contextMenuStripMuestras;
                }
            }
            dgvMuestras.ClearSelection();
            tabControl1.Enabled = true;
            btnEliminarProtocolo.Visible = muestras.Count.Equals(0) && RolUsuarioLogueado == Business.Roles.Administrativo;
            if (RolUsuarioLogueado == Business.Roles.Administrativo)
            {
                comboAnimales.Enabled = true;
                comboTiposDeMuestras.Enabled = true;
                btnGuardarMuestra.Enabled = true;
            }
            else
            {
                comboAnimales.Enabled = false;
                comboTiposDeMuestras.Enabled = false;
                btnGuardarMuestra.Enabled = false;
            
            }
            btnCancelarMuestra.Enabled = true;
        }

        private void btnCancelarMuestra_Click(object sender, EventArgs e)
        {
            reiniciarFormularioMuestra();
        }

        private void dgvAnalisis_RowHeaderMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            if (!e.RowIndex.Equals(-1))
            {
                reiniciarFormularioAnalisis();
                DataGridViewRow fila = dgvAnalisis.Rows[e.RowIndex];
                datosAnalisis.Text = "Editar Análisis";
                comboTipoDeAnalisis.SelectedIndex = comboTipoDeAnalisis.FindString(fila.Cells[0].Value.ToString());
                cargarIndicadores();
                richHistorial.Text = fila.Cells[2].Value.ToString();
                idAnalisisSeleccionado = Convert.ToInt32(fila.Cells[3].Value);
                btnCancelarAnalisis.Visible = true;
                if (fila.Cells[1].Value.ToString() == "Finalizado")
                {
                    comboTipoDeAnalisis.Enabled = false;
                    comboEstadoDeAnalisis.Enabled = false;
                    txtObservaciones.Enabled = false;
                    btnResultados.Enabled = false;
                    comboEstadoDeAnalisis.SelectedIndex = 2;
                    linkLabel1.Visible = true;
                }
                else
                {
                    linkLabel1.Visible = false;
                    if (RolUsuarioLogueado == Business.Roles.Administrativo)
                    {
                        comboTipoDeAnalisis.Enabled = true;
                    }
                    else 
                    {
                        comboTipoDeAnalisis.Enabled = false;
                    }
                    comboEstadoDeAnalisis.Enabled = true;
                    txtObservaciones.Enabled = true;
                    btnResultados.Enabled = true;
                    comboEstadoDeAnalisis.SelectedIndex = 0;
                }

                if (fila.Cells[1].Value.ToString() == "En Proceso")
                {
                    comboTipoDeAnalisis.Enabled = false;
                    comboEstadoDeAnalisis.SelectedIndex = 1;
                }

                datosAnalisis.Enabled = (RolUsuarioLogueado == Business.Roles.Laboratorio) || (RolUsuarioLogueado == Business.Roles.Administrativo);
                tipoDeMuestraAnterior = -1;
            }
         }

        private void comboVeterinarios_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (tabControl1.TabPages.Count == 3)
            {
                tabControl1.TabPages.RemoveAt(1);
                tabControl1.TabPages.RemoveAt(1);
            }
            else
            {
                if (tabControl1.TabPages.Count == 2)
                {
                    tabControl1.TabPages.RemoveAt(1);
                }
            }

            reiniciarFormularioMuestra();
            reiniciarFormularioAnalisis();
            dgvMuestras.Rows.Clear();
            dgvMuestras.DataSource = null;
            
            if (!comboVeterinarios.Text.Equals("[SELECCIONE VETERINARIO]"))
            {
                cargarProtocolos();
                cargarAnimales();
                lblProtocolo.Visible = comboProtocolos.Visible = true;
            }
            else
            {
                comboProtocolos.Items.Clear();
                dgvMuestras.Rows.Clear();
               
                tabControl1.Enabled = false;
                reiniciarFormularioMuestra();
                reiniciarFormularioAnalisis();
                comboAnimales.DataSource = null;
                lblProtocolo.Visible = comboProtocolos.Visible = false;
                btnEliminarProtocolo.Visible = false;
            }
        }

        private void cargarProtocolos(int? idProtocoloSeleccion = null)
        {
            comboProtocolos.Items.Clear();
            comboProtocolos.Enabled = true;
            foreach (Protocolo p in Muestras.CargarProtocolos(veterinarios[comboVeterinarios.Text]))
            {
                comboProtocolos.Items.Add(p);
                if (idProtocoloSeleccion.HasValue && p.IdProtocolo.Equals(idProtocoloSeleccion.Value))
                {
                    comboProtocolos.SelectedItem = p;
                }
            }
            if(RolUsuarioLogueado == Business.Roles.Administrativo)
            {
                comboProtocolos.Items.Insert(0, "[NUEVO PROTOCOLO]");
            }
                if (!idProtocoloSeleccion.HasValue)
            {
                if (comboProtocolos.Items.Count >= 1)
                {
                    comboProtocolos.SelectedIndex = 0;
                }
                else
                {
                    comboProtocolos.Items.Insert(0, "[SIN PROTOCOLOS]");
                    comboProtocolos.SelectedIndex = 0;
                    comboProtocolos.Enabled = false;
                    comboTiposDeMuestras.Enabled = false;
                }
                
            }
        }

        private void comboProtocolos_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (tabControl1.TabPages.Count == 3)
            {
                tabControl1.TabPages.RemoveAt(1);
                tabControl1.TabPages.RemoveAt(1);
            }
            else
            {
                if (tabControl1.TabPages.Count == 2)
                {
                    tabControl1.TabPages.RemoveAt(1);
                }
            }
            reiniciarFormularioAnalisis();
            reiniciarFormularioMuestra();
            cargarAnimales();
            Protocolo p = comboProtocolos.SelectedItem as Protocolo;
            idProtocolo = (p != null) ? p.IdProtocolo : 0;
            if (!idProtocolo.Equals(0))
            {
                cargarMuestras();
            }
            else if(RolUsuarioLogueado == Business.Roles.Administrativo)
            {
                foreach (Control c in datosMuestra.Controls)
                {
                    c.Enabled = RolUsuarioLogueado == Business.Roles.Administrativo;
                }
                if (MessageBox.Show("¿Desea crear un protocolo para el veterinario " + comboVeterinarios.Text + "?", "Confirmación Protocolo", MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
                {
                    p = Muestras.CrearProtocolo(veterinarios[comboVeterinarios.Text]);
                    cargarProtocolos(p.IdProtocolo);
                    idProtocolo = p.IdProtocolo;
                }
                else
                {
                    dgvMuestras.Rows.Clear();
                    comboAnimales.Enabled = false;
                    comboTiposDeMuestras.Enabled = false;
                    btnGuardarMuestra.Enabled = false;
                }
            }

            
        }

        private void dgvAnalisis_MouseDown(object sender, MouseEventArgs e)
        {
            if (!dgvAnalisis.HitTest(e.X, e.Y).RowIndex.Equals(-1))
            {
                dgvAnalisis.ClearSelection();
                dgvAnalisis.Rows[dgvAnalisis.HitTest(e.X, e.Y).RowIndex].Selected = true;
            }
        }

        private void dgvMuestras_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            if(!e.RowIndex.Equals(-1))
            {
                dgvMuestras.Rows[e.RowIndex].Selected = true;
            }
        }

        private void dgvIndicadores_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            if (!e.RowIndex.Equals(-1))
            {
                dgvIndicadores.Rows[e.RowIndex].Selected = true;
            }
        }

        private void dgvAnalisis_CellClick(object sender, DataGridViewCellEventArgs e)
        {
            if (!e.RowIndex.Equals(-1))
            {
                dgvAnalisis.Rows[e.RowIndex].Selected = true;
            }
        }

        private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (tabControl1.SelectedIndex.Equals(0))
            {
                reiniciarFormularioMuestra();
                cargarMuestras();
                if (tabControl1.TabPages.Count == 3)
                {
                    tabControl1.TabPages.RemoveAt(1);
                    tabControl1.TabPages.RemoveAt(1);
                }
                else 
                {
                    if (tabControl1.TabPages.Count == 2)
                    {
                        tabControl1.TabPages.RemoveAt(1);
                    }
                }
             }
        }

        private void comboEstadoDeAnalisis_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (comboEstadoDeAnalisis.SelectedIndex + 1 == (int)SIIV.Business.AnalisisBusiness.EstadosDeAnalisis.Finalizado)
            {
                btnResultados.Visible = true;
                btnGuardarAnalisis.Visible = false;
            }
            else
            {
                btnResultados.Visible = false;
                btnGuardarAnalisis.Visible = true;
                btnGuardarAnalisis.Enabled = true;
            }
        }

        private void btnResultados_Click(object sender, EventArgs e)
        {
            if (tabControl1.TabPages.Count <= 2)
            {
                tabControl1.TabPages.Add(tabResultados);
                tabControl1.SelectedTab = tabResultados;
                cargarResultadosDeAnalisis();
            }
            else
                tabControl1.SelectedTab = tabResultados;
            cargarIndicadores();
            txtValor.Enabled = true;
            comboPosNeg.Enabled = true;
            comboIndicadores.Enabled = true;
            btnGuardarIndicador.Enabled = true;
            btnFinalizar.Enabled = true;
         }

        private void cargarResultadosDeAnalisis()
        {
            dgvIndicadores.Rows.Clear();
            foreach (ResultadoDeAnalisis r in Muestras.ObtenerResultadosAnalisis(idAnalisisSeleccionado))
            {
                dgvIndicadores.Rows.Add(r.Indicador.Nombre, r.Valor, r.IdResultadoDeAnalisis);
                dgvIndicadores.Rows[dgvIndicadores.Rows.Count - 1].ContextMenuStrip = contextMenuStripIndicadores;
            }
            dgvIndicadores.ClearSelection();
        }

        private void cargarUnidades()
        {
            comboUnidades.DataSource = Muestras.ObtenerUnidades();
        }

        private void cargarComboPosNeg()
        {
            comboPosNeg.Items.Add("Positivo");
            comboPosNeg.Items.Add("Negativo");
            comboPosNeg.SelectedIndex = 0;
        }
        private void cargarIndicadores()
        {
            comboIndicadores.DataSource = Muestras.ObtenerIndicadores(Convert.ToInt16(comboTipoDeAnalisis.SelectedValue));
        }

        private void eliminarIndicadorToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Int32 fila = dgvIndicadores.Rows.GetFirstRow(DataGridViewElementStates.Selected);
            try
            {
                Muestras.EliminarResultadoAnalisis(Convert.ToInt32(dgvIndicadores.Rows[fila].Cells[2].Value));
                cargarResultadosDeAnalisis();
            }
            catch (Exception ex)
            {
                MostrarError(ex.Message);
            }
        }

        private void btnGuardarIndicador_Click(object sender, EventArgs e)
        {
            dgvIndicadores.Enabled = true;
            if (txtValor.Text == string.Empty && txtValor.Visible == true)
            {
                MostrarError("Ingrese el valor del indicador");
            }
            else
            {
                try
                {
                    if (comboUnidades.Text != "Positivo o Negativo")
                    {
                        if (System.Text.RegularExpressions.Regex.IsMatch(txtValor.Text, "^([0-9]{1,4}[,]{0,1}[0-9]{0,3})$") == true)
                        {
                            if (comboUnidades.Text == "%")
                            {
                                if (Convert.ToDecimal(txtValor.Text) >= 0 && Convert.ToDecimal(txtValor.Text) <= 100)
                                {
                                    Muestras.GuardarResultadoAnalisis(idAnalisisSeleccionado, Convert.ToInt16(comboIndicadores.SelectedValue), txtValor.Text, Convert.ToInt32(comboUnidades.SelectedValue));
                                    cargarResultadosDeAnalisis();                                    
                                    btnFinalizar.Focus();
                                    txtValor.Text = null;
                                }
                                else
                                {
                                    MostrarError("Formato Invalido, ingrese otro valor");
                                    txtValor.Focus();
                                }
                            }
                            else
                            {
                                Muestras.GuardarResultadoAnalisis(idAnalisisSeleccionado, Convert.ToInt16(comboIndicadores.SelectedValue), txtValor.Text, Convert.ToInt32(comboUnidades.SelectedValue));
                                cargarResultadosDeAnalisis();
                                btnFinalizar.Focus();
                                txtValor.Text = null;
                            }
                        }
                        else
                        {
                            MostrarError("Formato Inválido, ingrese otro valor");
                            txtValor.Focus();
                        }
                    }
                    else
                    {
                        Muestras.GuardarResultadoAnalisis(idAnalisisSeleccionado, Convert.ToInt16(comboIndicadores.SelectedValue), comboPosNeg.Text, Convert.ToInt32(comboUnidades.SelectedValue));
                        cargarResultadosDeAnalisis();
                        btnFinalizar.Focus();
                    }
                    
                                      
                }
                catch (Exception ex)
                {
                    MostrarError(ex.Message);
                }
            }
            comboIndicadores.SelectedIndex = 0;
        }

        private void btnFinalizar_Click(object sender, EventArgs e)
        {
            try
            {
                if (dgvIndicadores.Rows.Count > 0)
                {
                    Muestras.ActualizarAnalisis(idAnalisisSeleccionado, Convert.ToInt16(comboTipoDeAnalisis.SelectedValue), (short)(comboEstadoDeAnalisis.SelectedIndex + 1), txtObservaciones.Text, IdUsuarioLogueado);
                    cargarAnalisis();
                    reiniciarFormularioAnalisis();
                }
                else
                {
                    MostrarError("Para finalizar el análisis debe ingresar sus resultados.");
                }
            }
            catch (Exception ex)
            {
                MostrarError(ex.Message);
            }
        }

        private void btnEliminarProtocolo_Click(object sender, EventArgs e)
        {
            try
            {
                Muestras.EliminarProtocolo(idProtocolo);
                reiniciarFormularioMuestra();
                comboVeterinarios.SelectedIndex = 0;
                comboVeterinarios_SelectedIndexChanged(null, null);
            }
            catch (Exception ex)
            {
                MostrarError(ex.Message);
            }
        }

        private bool isNumero(string valor)
        {
            bool textIsNumeric = true;
            try
            {
                int.Parse(valor);
            }
            catch
            {
                textIsNumeric = false;
            }
            return textIsNumeric;
        }

        private void comboIndicadores_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (Convert.ToInt32(comboIndicadores.SelectedValue) != 0)
            {
                Indicador indicador = Muestras.ObtenerIndicador(Convert.ToInt32(comboIndicadores.SelectedValue));
                comboUnidades.SelectedValue = indicador.IdUnidad;
                txtValor.Text = null;
                if (comboUnidades.Text == "Positivo o Negativo")
                {
                    txtValor.Enabled = false;
                    txtValor.Visible = false;
                    comboUnidades.Visible = false;
                    label4.Visible = false;
                    comboPosNeg.Enabled = true;
                    comboPosNeg.Visible = true;
                }
                else
                {
                    txtValor.Enabled = true;
                    txtValor.Visible = true;
                    comboUnidades.Visible = true;
                    label4.Visible = true;
                    comboPosNeg.Enabled = false;
                    comboPosNeg.Visible = false;
                }
            }
        }

        private void txtValor_KeyPress(object sender, KeyPressEventArgs e)
        {
            //Permitimos solo números y  el símbolo .
            if (!char.IsDigit(e.KeyChar) && !char.IsControl(e.KeyChar) && e.KeyChar != 8 && e.KeyChar != 44)
                e.Handled = true; 
        }

        private void comboTiposDeMuestras_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (Convert.ToInt32(comboTiposDeMuestras.SelectedValue) != 0)
                {
                    if (validarCambioDeMuestra && RolUsuarioLogueado == Business.Roles.Administrativo && !tipoDeMuestraAnterior.Equals(Convert.ToInt32(comboTiposDeMuestras.SelectedValue)) && Muestras.ObtenerAnalisis(idMuestraSeleccionada).Count > 0)
                    {
                        if (MessageBox.Show("Al cambiar el tipo de muestra, los análisis se eliminarán.", "Eliminar Análisis", MessageBoxButtons.OKCancel) == System.Windows.Forms.DialogResult.OK)
                        {                            
                            Muestras.ActualizarMuestra(idProtocolo, idMuestraSeleccionada, Convert.ToInt32(comboAnimales.SelectedValue), Convert.ToInt16(comboTiposDeMuestras.SelectedValue));
                            Muestras.EliminarAnalisis(idMuestraSeleccionada);
                            cargarMuestras();
                        }
                        else
                        {
                            validarCambioDeMuestra = false;
                            comboTiposDeMuestras.SelectedIndex = tipoDeMuestraAnterior;
                        }
                    }
                    cargarTiposDeAnalisis();
                }
            }
            catch (Exception ex)
            {
                MostrarError(ex.Message);
            }
        }

        private void comboTipoDeAnalisis_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (Convert.ToInt32(comboIndicadores.SelectedValue) != 0)
            {
                cargarIndicadores();
            }
            if (tabControl1.TabPages.Count.Equals(3))
            {
                reiniciarFormularioResultadosDeAnalisis();
            }
            comboEstadoDeAnalisis.SelectedIndex = 0;
        }

        private void btnCancelarIndicador_Click(object sender, EventArgs e)
        {
            txtValor.Text = null;
            comboIndicadores.SelectedIndex = 0;
            if (!btnFinalizar.Enabled && !btnGuardarIndicador.Enabled)
            {
                tabControl1.SelectedIndex = 1;
                if (tabControl1.TabPages.Count == 3)
                {
                    tabControl1.TabPages.RemoveAt(2);
                    linkLabel1.Visible = false;
                }
            }
        }

        private void comboTiposDeMuestras_MouseClick(object sender, MouseEventArgs e)
        {
            validarCambioDeMuestra = true;
        }

        private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            if (tabControl1.TabPages.Count <= 2)
            {
                tabControl1.TabPages.Add(tabResultados);
                tabControl1.SelectedTab = tabResultados;
                cargarResultadosDeAnalisis();
            }
            else
                tabControl1.SelectedTab = tabResultados;
            cargarIndicadores();
            comboIndicadores.Enabled = false;
            comboPosNeg.Enabled = false;
            txtValor.Enabled = false;
            comboUnidades.Enabled = false;
            btnGuardarIndicador.Enabled = false;
            btnFinalizar.Enabled = false;
            dgvIndicadores.Enabled = false;
        }
                           
    }
}
